﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include<vector>
#include<list>
#include<stack>
#include<algorithm>
#include<iostream>
using namespace std;
/*283 移动0  给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。*/


//class Solution {
//public:
//    void moveZeroes(vector<int>& nums) {
//        int size = nums.size();
//        int left = 0;
//        int right = 0;
//        while (right != size)
//        {
//            if (nums[right] != 0)
//            {
//                swap(nums[left], nums[right]);
//                right++;
//                left++;
//            }
//            else
//                right++;
//        }
//    }
//};

//class Solution {
//public:
//    void moveZeroes(vector<int>& nums) {
//        for (int cur = 0, des = -1; cur < nums.size(); cur++)
//            if (nums[cur])
//                swap(nums[cur], nums[++des]);
//    }
//};


/*1089复写0*/
/*给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。*/


//class Solution {
//public:
//    void duplicateZeros(vector<int>& arr) {
//        int des = -1;
//        int cur = 0;
//        int n = arr.size();
//        while (true)
//        {
//            if (arr[cur])
//                des++;
//            else
//            {
//                des += 2;
//            }
//            if (des >= n - 1) break;
//            cur++;
//        }
//        if (des >= n)
//        {
//            arr[n - 1] = 0;
//            des -= 2;
//            cur--;
//        }
//        while (cur >= 0)
//        {
//            if (arr[cur])
//            {
//                arr[des--] = arr[cur--];
//            }
//            else
//            {
//                arr[des--] = 0;
//                arr[des--] = 0;
//                cur--;
//            }
//        }
//    }
//};


/*202快乐数*/
/*编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。*/


//class Solution {
//public:
//    int bitmath(int n)
//    {
//        int sum = 0;
//        while (n > 0)
//        {
//            sum += (n % 10) * (n % 10);
//            n /= 10;
//        }
//        return sum;
//    }
//    bool isHappy(int n) {
//        int fast = n;
//        int slow = n;
//        do
//        {
//            fast = bitmath(bitmath(fast));
//            slow = bitmath(slow);
//        } while (fast != slow);
//        return slow == 1 && fast == 1;
//    }
//};


/*11  盛水最多的容器*/
/*给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。*/
//
//class Solution {
//public:
//    int maxArea(vector<int>& height) {
//        priority_queue<int, vector<int>, std::less<int>> it;
//        int left = 0;
//        int right = height.size() - 1;
//        while (left <= right)
//        {
//            int n = right - left;
//            int l = height[left];
//            int r = height[right];
//            if (l > r)
//            {
//                it.push(r * n);
//                right--;
//            }
//            else
//            {
//                it.push(l * n);
//                left++;
//            }
//        }
//        return it.top();
//    }
//};




/*611 有效三角形的个数*/
/*给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。*/
//class Solution {
//public:
//    int triangleNumber(vector<int>& nums) {
//        sort(nums.begin(), nums.end());
//        int cur = nums.size() - 1;
//        int sum = 0;
//        for (cur; cur > 1; cur--)
//        {
//            int left = 0;
//            int right = cur - 1;
//            while (left < right)
//            {
//                if ((nums[right] + nums[left] > nums[cur]) && (nums[right] > 0 && nums[left] > 0))
//                {
//                    sum += right - left;
//                    right--;
//                }
//                else
//                {
//                    left++;
//                }
//            }
//        }
//        return sum;
//    }
//};


/*/二分查找注意事项：
在二分查找中，通常遇到的两个问题：

while 循环的条件？
a. left <= right ？
b. left < right？
right 每次移动的位置？
a. right = mid - 1？
b. right = mid？
以上两个问题的关键点就在于我们对于数组操作时，所选择的查询区间，一般分为两种：
3. 左闭右闭 ->> [ ] 表示从最左边到最右边的区间查找，例如[1, 3] 就是 1，2，3
4. 左闭右开 ->> [ ）表示从最左边到最右边 - 1的区间查找，例如[1,3)就是1，2

解决
以上两个问题的关键点就在于我们对于数组操作时，所选择的查询区间，一般分为两种：

左闭右闭 ->> [ ] 表示从最左边到最右边的区间查找，例如[1, 3] 就是 1，2，3
左闭右开 ->> [ ）表示从最左边到最右边 - 1的区间查找，例如[1,3)就是1，2
所以首先确定好自己所选取的区间就可以解决上述两个问题了：

左闭右闭，这说明我们需要查询的数据就是包含在这个范围里面的，不在范围里面的都不满足条件查询，比如 [1,3]，就表示从1查到3。
a. 这样第一个问题就可以解决了，我们可以举例子来说明，如果最后就剩了一个3，那么区间表示[3,3]符合我们上面的定义，在区间内的都需要查询。所以应该是 left <= right。
b. 第二个问题也是同样的意思，当我们比较的是如果target < nums[mid]才需要对 right 赋值，那么这时其实已经对 mid 这个位置进行了比较，其实已经不满足我们的条件了
并不应该出现在我们的查询范围中，所以应该是 right = mid - 1，这样[left，right] 还是满足左闭右闭，在整个区间内都进行查询。

左闭右开，这说明我们需要查询的数据其实是从左边开始到右边的数字 - 1的范围，并不包含最右边的数字。比如[1,3)，就表示从 1 查到 2。
a. 这样第一个问题就说明：当我们同样剩最后一个数字三的时候，区间表示[3,3)这并不符合我们区间的定义，既要查3，但是又不应该查3。所以我们应该是不能让left = right
所以应该是 left < right。
b. 同样的第二个问题，这时候发现 mid 索引的位置其实已经不满足条件了，但是 mid - 1 的还没有检查，所以我们需要包含 mid - 1 的位置
这时我们就应该让 right = mid，这样也是符合我们的区间定义[left, right）但是不包含right。

/*洛谷8775：青蛙跳河（蓝桥杯22省A原题）*/
/*小青蛙住在一条河边，它想到河对岸的学校去学习。小青蛙打算经过河里的石头跳到对岸。

河里的石头排成了一条直线，小青蛙每次跳跃必须落在一块石头或者岸上。不过，每块石头有一个高度,
每次小青蛙从一块石头起跳，这块石头的高度就会下降 1，当石头的高度下降到 0 时小青蛙不能再跳到这
块石头上(某次跳跃后使石头高度下降到0是允许的)。
小青蛙一共需要去学校上 x 天课，所以它需要往返 2x 次。当小青蛙具有一个跳跃能力 y 时，它能跳不超
过 y 的距离。

请问小青蛙的跳跃能力至少是多少才能用这些石头上完x次课。

输入格式
输入的第一行包含两个整数 n,x,分别表示河的宽度和小青蛙需要去学校的天数。请注意 2x 才是实际过河
的次数。
第二行包含 几 -1个非负整数 H,,H2,…·,H-1,其中 H;>0表示在河中与 小青蛙的家相距讠的地方
有一块高度为 H,的石头，H,=0 表示这个位置没有石头。

输出格式
输出一行,包含一个整数,表示小青蛙需要的最低跳跃能力。*/

/*思路：题目可以总结为共有2x只青蛙要过河*/
/*跳跃能力的值就是 1 到 n  （ps：跳跃能力为n的时候可以跳过n-1个石头，而不是n-1的时候能跳跃n-1个石头）
将跳跃能力的值二分（mid=(left+right)/2）mid代表跳跃能力，通过判断当前的跳跃能力是否能够使 2x 只青蛙跳过岸。
如果能过，right=mid-1，来缩小跳跃能力的边界
如果不能过，left=mid+1,来增加跳跃能力的边界
最后输出left或者right，就是最终的跳跃能力最小值。
*/

//#include<bits/stdc++.h>
//using namespace std;
//const int n = 1e5;
//long long arr[n], sum[n];
//bool check(int mid, int x, int n)
//{
//    for (int i = mid; i < n; i++)
//    {
//        if (sum[i] - sum[i - mid] < 2 * x)
//        {
//            return false;
//        }
//    }
//    return true;
//}
//int main()
//{
//    int n, x;
//    cin >> n >> x;
//    sum[0] = 0;
//    for (int i = 1; i < n; i++)
//    {
//        cin >> arr[i];
//        sum[i] = arr[i] + sum[i - 1];
//    }
//    int l = 1, r = n;
//    int ans;
//    while (l <= r)
//    {
//        int mid = (l + r) / 2;
//        if (check(mid, x, n))
//        {
//            r = mid - 1;
//        }
//        else
//        {
//            l = mid + 1;
//        }
//    }
//    cout << l;
//}
#define int long long
using namespace std;
const int N = 2e5 + 1;
int arr[N], n;
int sum = 0;
int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    for (int i = 0; i < n; i++)
    {
        int x = arr[i];
        for (int j = 1; j <= n; j++)
        {
            sum += arr[j] * x;
        }
    }
    cout << sum;
    return 0;
}